Micron Document
`:top
`!Dynamic Link Library`! (aus dem `F33f`_`[Englischen`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Amerikanisches_Englisch]`_`f entlehnt; kurz `!DLL`!) bezeichnet allgemein eine `F33f`_`[dynamische Programmbibliothek`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Programmbibliothek]`_`f; meist bezieht sich der Begriff jedoch auf die für die `F33f`_`[Betriebssysteme`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Betriebssystem]`_`f `F33f`_`[Windows`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Microsoft_Windows]`_`f und `F33f`_`[OS/2`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=OS/2]`_`f verwendete Variante.`:cite-ref-1[`F5bf`_`[1`#cite-note-1]`_`f]`:cite-ref-2[`F5bf`_`[2`#cite-note-2]`_`f]

DLL-`F33f`_`[Dateien`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Datei]`_`f verwenden das auch für ausführbare `F33f`_`[EXE`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=EXE]`_`f-Dateien gebräuchliche `F33f`_`[Dateiformat`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Dateiformat]`_`f, das in 16-Bit-Programmen das `F33f`_`[New-Executable`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=New_Executable]`_`f-Format,`:cite-ref-ne-3-0[`F5bf`_`[3`#cite-note-ne-3]`_`f] in 16- und 32-Bit-Programmen das `F33f`_`[Linear-Executable`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Linear_Executable]`_`f-Format sowie in 32- und 64-Bit-Programmen das `F33f`_`[Portable-Executable`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Portable_Executable]`_`f-Format ist. Diese Dateien können Programmcode (`F33f`_`[Maschinencode`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Maschinensprache]`_`f), Daten und `F33f`_`[Ressourcen`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Ressource_(Software)]`_`f in beliebiger Kombination enthalten.

Die Windows-`F33f`_`[Dateinamenserweiterung`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Dateinamenserweiterung]`_`f für solche Bibliotheken ist gewöhnlich `B100`F9d9DLL`f`b. Zudem können es jedoch auch andere Dateiendungen, wie `B100`F9d9CPL`f`b (für die `F33f`_`[Systemsteuerung`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Systemsteuerung]`_`f), `B100`F9d9OCX`f`b (für Bibliotheken mit `F33f`_`[ActiveX`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=ActiveX]`_`f-Steuerelementen) oder auch `B100`F9d9DRV`f`b (für `F33f`_`[Treiber`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Gerätetreiber]`_`f), sein.

>>Contents

• `F0af`_`[Hintergrund`#hintergrund]`_`f
• `F0af`_`[Weitere Vorteile`#weitere-vorteile]`_`f
• `F0af`_`[Schwächen`#schw-chen]`_`f
• `F0af`_`[Betriebssysteminterne Behandlung`#betriebssysteminterne-behandlung]`_`f
• `F0af`_`[Laden von DLLs bei einem Programmstart`#laden-von-dlls-bei-einem-programmstart]`_`f
• `F0af`_`[DLL-Datei-Aufbau`#dll-datei-aufbau]`_`f
• `F0af`_`[Aufruf eines DLL-Befehles durch ein Programm`#aufruf-eines-dll-befehles-durch-ein-programm]`_`f
• `F0af`_`[DLLs im Speicher`#dlls-im-speicher]`_`f
• `F0af`_`[DLL-Instanzenzähler`#dll-instanzenz-hler]`_`f
• `F0af`_`[Programmierbeispiele für 32-Bit Windows`#programmierbeispiele-f-r-32-bit-windows]`_`f
• `F0af`_`[Arbeiten mit DLLs in Visual C++`#arbeiten-mit-dlls-in-visual-c]`_`f
• `F0af`_`[Verwenden von DLLs in Object Pascal`#verwenden-von-dlls-in-object-pascal]`_`f
• `F0af`_`[DLLs in Visual Basic Classic verwenden`#dlls-in-visual-basic-classic-verwenden]`_`f
• `F0af`_`[Win32-DLLs im .Net-Framework verwenden`#win32-dlls-im-net-framework-verwenden]`_`f
• `F0af`_`[Siehe auch`#siehe-auch]`_`f
• `F0af`_`[Weblinks`#weblinks]`_`f
• `F0af`_`[Einzelnachweise`#einzelnachweise]`_`f

-─

>>Hintergrund

→

Hauptartikel

:

Programmbibliothek

Der Hauptzweck von DLL-Dateien ist, den von Anwendungen auf der Festplatte und im Hauptspeicher benötigten Speicherplatz zu reduzieren. Code und Daten, die von mehr als einer Anwendung benötigt werden könnten, werden deshalb in einer einzelnen Datei auf der `F33f`_`[Festplatte`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Massenspeicher]`_`f gespeichert und nur einmal in den Hauptspeicher geladen, wenn mehrere Programme dieselbe Programmbibliothek benötigen.`:cite-ref-4[`F5bf`_`[4`#cite-note-4]`_`f]

>>>Weitere Vorteile

Wird ein Stück Programmcode verbessert, müssen nicht alle Programme geändert werden, die diesen Code nutzen, sondern es genügt, ihn in der DLL zu aktualisieren. Alle Programme können in diesem Fall auf die aktualisierte Fassung zugreifen. Dadurch ist es Softwareentwicklern möglich, relativ kleine `F33f`_`[Patches`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Patch_(Software)]`_`f für größere Softwarepakete herauszugeben, beispielsweise auch für ganze Betriebssysteme. Ein ganzes Paket kann so durch die Aktualisierung einzelner DLLs auf den neuesten Stand gebracht werden.

In Form von `F33f`_`[Plug-ins`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Plug-in]`_`f können mit DLLs neue Programmteile für ein bereits bestehendes Programm erstellt und darin nahtlos integriert werden, ohne dass am schon existierenden Programm Veränderungen vorgenommen werden müssten. Diese Idee der dynamischen „Einbindbarkeit“ wird zum Beispiel unter Windows durch `F33f`_`[ActiveX`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=ActiveX]`_`f realisiert.

Auch können durch solch einen modularen Aufbau nicht benötigte Funktionen einfach deaktiviert werden.

>>>Schwächen

Ein bei Windows auch `F33f`_`[DLL-Konflikt`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=DLL-Konflikt]`_`f genanntes Problem tritt auf, wenn mehrere Anwendungen verschiedene Versionen der gleichen DLL benötigen. Falls einem Programm die erforderliche Version fehlt, kann das zu Problemen, wie fehlerhaften Installationen, führen. Dieser Konflikt kann oft behoben werden, indem die jeweils richtige Version der Programmbibliothek in den Programmordner des jeweiligen Programms kopiert wird. Der Effekt der Speicherersparnis wird dadurch allerdings wieder zunichtegemacht. Mit `F33f`_`[Microsoft .NET`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Microsoft_.NET]`_`f ist es möglich, Versionskonflikte bei DLL-Dateien zu umgehen, indem sie die gleichzeitige Existenz von mehreren Versionen einer Programmbibliothek ermöglichen. Dies ist aber nur für mit .NET entwickelte DLL-Dateien möglich.

In bestimmten Fällen ist `F33f`_`[DLL Hijacking`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=DLL_Hijacking]`_`f oder die bösartige Nutzung von `F33f`_`[DLL-Injection`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=DLL-Injection]`_`f möglich.

>>Betriebssysteminterne Behandlung

>>>Laden von DLLs bei einem Programmstart

Wenn ein Programm ausgeführt werden soll, dann wird es vom Loader des Betriebssystems in den Speicher geladen und die „Import-Tabelle“ des Programms ausgelesen. In dieser Tabelle befinden sich alle DLL-Befehls-Namen oder die Ordnungszahlen der DLL-Befehle, die von diesem Programm benötigt werden. Der Loader lädt nun die fehlenden DLLs in den Speicher und fügt in der Import-Tabelle des Programms die Einsprungadressen der einzelnen Befehle ein.

>>>DLL-Datei-Aufbau

Eine DLL hat (nach dem `F33f`_`[MZ-Header`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=MZ-Datei]`_`f) denselben `F33f`_`[NE`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=New_Executable]`_`f-, `F33f`_`[LE/LX`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Linear_Executable]`_`f- oder `F33f`_`[PE`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Portable_Executable]`_`f-Header wie eine normale `F33f`_`[ausführbare Datei`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Ausführbare_Datei]`_`f, nur ist im Falle einer NE der DWORD-Flag an der Adresse 0Chex im NE-Header auf 8000hex gesetzt (Library Module flag)`:cite-ref-ne-3-1[`F5bf`_`[3`#cite-note-ne-3]`_`f] beziehungsweise im PE-Header im `*Characteristics`*-Wert das `*IMAGE_FILE_DLL`*-Bit gesetzt. Während sowohl DLLs als auch ausführbare Dateien eine „Export-Tabelle“ besitzen können, wird dies bei letzteren selten benutzt. In dieser Export-Tabelle sind alle Namen der Funktionen und Variablen aufgelistet, die die DLL an externe Software zur Verfügung stellt. Diese Namen müssen alphabetisch sortiert sein, damit der Loader sie finden kann.

>>>Aufruf eines DLL-Befehles durch ein Programm

Zuerst werden die zu übergebenden Werte – sinngemäß wie bei anderen `F33f`_`[Unterprogrammen`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Unterprogramm]`_`f – auf dem `F33f`_`[Stack`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Stapelspeicher]`_`f abgelegt, dann wird ein indirekter Sprung auf den Wert der vom Loader in der Import-Tabelle hinterlegten DLL-Adresse durchgeführt.

>>>DLLs im Speicher

Es gibt zwei verschiedene Varianten, wie DLLs vom Betriebssystem in den Speicher geladen werden können. Es gibt statische DLLs, die nur einmal geladen werden. Alle Programme greifen dann auf diese eine Instanz der DLL zu. Diese DLL besitzt dann nur einen einzigen globalen Speicherbereich. Die Windows-Kernel-DLLs sind solche statischen DLLs, was ihnen erlaubt, das gesamte System zu verwalten (z. B. alle offenen Dateien zu überwachen). Eine andere Variante DLLs im Speicher zu verwalten, ist die, dass jedes Mal, wenn ein neues Programm eine DLL benötigt, eine neue Instanz von dieser in den Speicher geladen wird.

Ob eine DLL statisch ist oder nicht, legt ein weiteres Flag im Header der DLL fest.

>>>DLL-Instanzenzähler

Jedes Mal, wenn eine DLL von einem Programm geladen wird, wird ein interner Instanzenzähler für diese DLL erhöht. Über diesen Zähler kann das System erkennen, ob eine DLL noch in Verwendung ist oder entladen werden kann. Letzteres geschieht, wenn der Instanzenzähler null erreicht, da das letzte laufende Programm, welches die DLL benutzt hat, die DLL entladen hat und diese nicht weiter im Speicher vorgehalten werden muss.

>>Programmierbeispiele für 32-Bit Windows

>>>Arbeiten mit DLLs in Visual C++

>>>>Erstellen einer DLL mit einer Funktion

Die DLL-Schnittstelle wird mit Hilfe der Export-Funktion `B100`F9d9__declspec(dllexport)`f`b definiert.
Dies wird im folgenden Beispiel demonstriert:

`B100`F9d9// Nur unter Microsoft Visual C++ hat das Makro "DLL" eine Funktion.`f`b
`B100`F9d9// Unter zum Beispiel Linux ist das Makro "DLL" leer.`f`b
`B100`F9d9`f`b
`B100`F9d9#if defined(_MSC_VER)`f`b
`B100`F9d9 #include <windows.h>`f`b
`B100`F9d9 #define DLL extern "C" __declspec(dllexport)`f`b
`B100`F9d9#else`f`b
`B100`F9d9 #define DLL`f`b
`B100`F9d9#endif`f`b
`B100`F9d9`f`b
`B100`F9d9// Die Funktion, die anderen Programmen zur Verfügung gestellt werden soll`f`b
`B100`F9d9// (in diesem Beispiel: Addieren zweier Zahlen)`f`b
`B100`F9d9`f`b
`B100`F9d9DLL double AddNumbers (double a, double b)`f`b
`B100`F9d9{`f`b
`B100`F9d9 return a + b ;`f`b
`B100`F9d9}`f`b

Dieses Beispiel erzeugt beim Kompilieren sowohl eine `B100`F9d9DLL`f`b als auch eine `B100`F9d9LIB`f`b-Datei.

>>>>Einbinden einer DLL und Aufrufen dieser Funktion

DLL-Funktionen können einfach aufgerufen werden, nachdem man sie mit der Funktion `B100`F9d9__declspec(dllimport)`f`b importiert hat.

`B100`F9d9#include <windows.h>`f`b
`B100`F9d9#include <stdio.h>`f`b
`B100`F9d9`f`b
`B100`F9d9// Importieren der Funktion aus der oben erstellten DLL`f`b
`B100`F9d9extern "C" __declspec(dllimport) double AddNumbers (double a, double b) ;`f`b
`B100`F9d9`f`b
`B100`F9d9int main (void)`f`b
`B100`F9d9{`f`b
`B100`F9d9 // Aufrufen der externen Funktion`f`b
`B100`F9d9 double result = AddNumbers (1, 2) ;`f`b
`B100`F9d9`f`b
`B100`F9d9 printf ("Das Ergebnis ist: %f\\n", result) ;`f`b
`B100`F9d9 return 0 ;`f`b
`B100`F9d9}`f`b

Zu beachten ist, dass der Linker die LIB-Datei benötigt und dass sich die DLL-Datei im selben Ordner wie das Programm, das sie aufrufen soll, befinden sollte. Die LIB-Datei wird vom Linker benötigt, damit er „Platzhalter“ für die später aus der DLL aufgerufenen Funktionen einbauen kann.

>>>>Einbinden einer DLL zur Laufzeit und Aufrufen dieser Funktion

DLL-Bibliotheken können auf zwei verschiedene Weisen in eine Anwendung geladen werden: entweder gleich beim Starten des Programms (so wie in den obigen Beispielen beschrieben) oder erst später während der Laufzeit, indem man die `F33f`_`[API`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Programmierschnittstelle]`_`f-Funktionen `B100`F9d9LoadLibrary`f`b, `B100`F9d9GetProcAddress`f`b und `B100`F9d9FreeLibrary`f`b verwendet. Die Art und Weise, wie DLLs während der Laufzeit einzubinden sind, ist in jeder Programmiersprache gleich, solange man eine `F33f`_`[Windows-API`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Windows_API]`_`f-Funktion importieren möchte. Der folgende Code demonstriert das anhand eines VC++-Beispieles:

`B100`F9d9#include <windows.h>`f`b
`B100`F9d9#include <stdio.h>`f`b
`B100`F9d9`f`b
`B100`F9d9// Definition des Types der DLL-Funktion, die verwendet werden soll`f`b
`B100`F9d9typedef double (*BinaryFunction_t) (double, double) ;`f`b
`B100`F9d9`f`b
`B100`F9d9int main (void)`f`b
`B100`F9d9{`f`b
`B100`F9d9 BinaryFunction_t AddNumbers ;`f`b
`B100`F9d9 double result ;`f`b
`B100`F9d9 BOOL fFreeResult ;`f`b
`B100`F9d9`f`b
`B100`F9d9 // DLL-Datei laden`f`b
`B100`F9d9 HINSTANCE hinstLib = LoadLibrary ("MyDll.dll") ;`f`b
`B100`F9d9`f`b
`B100`F9d9 if (hinstLib != NULL)`f`b
`B100`F9d9 {`f`b
`B100`F9d9 // Die Einsprungadresse abfragen`f`b
`B100`F9d9 AddNumbers = (BinaryFunction_t) GetProcAddress (hinstLib, "AddNumbers") ;`f`b
`B100`F9d9`f`b
`B100`F9d9 // Die Funktion aufrufen`f`b
`B100`F9d9 if ( AddNumbers != NULL )`f`b
`B100`F9d9 result = (*AddNumbers) (1, 2) ;`f`b
`B100`F9d9`f`b
`B100`F9d9 // Die DLL-Datei wieder entladen`f`b
`B100`F9d9 fFreeResult = FreeLibrary (hinstLib) ;`f`b
`B100`F9d9 }`f`b
`B100`F9d9`f`b
`B100`F9d9 // Das Ergebnis anzeigen`f`b
`B100`F9d9 if (hinstLib == NULL || AddNumbers == NULL)`f`b
`B100`F9d9 printf ("Fehler: Konnte die Funktion nicht aufrufen\\n") ;`f`b
`B100`F9d9 else`f`b
`B100`F9d9 printf ("Das Ergebnis ist: %f\\n", result) ;`f`b
`B100`F9d9`f`b
`B100`F9d9 return 0 ;`f`b
`B100`F9d9}`f`b

Die `B100`F9d9LIB`f`b-Datei wird in diesem Fall nicht benötigt. Die `B100`F9d9DLL`f`b-Datei muss aber immer noch in einem Ordner liegen, der dem Programm zugänglich ist.

Zu beachten ist außerdem, dass beim Versuch, eine nicht vorhandene DLL direkt beim Programmstart automatisch mitladen zu lassen, vom Betriebssystem eine Fehlermeldung angezeigt und das Programm beendet wird, ohne dass der Programmierer eine Möglichkeit hat, diesen Fehler abzufangen. Beim Einbinden von DLLs während der Laufzeit können Fehler beim Laden hingegen abgefangen werden.

>>>Verwenden von DLLs in Object Pascal

>>>>Erstellen einer DLL

Im Kopf des Quellcodes muss das Schlüsselwort `B100`F9d9library`f`b an Stelle von `B100`F9d9program`f`b verwendet werden. Am Ende der Datei werden dann die zu exportierenden Funktionen im `B100`F9d9exports`f`b-Bereich aufgelistet:

`B100`F9d9 library Beispiel;`f`b
`B100`F9d9`f`b
`B100`F9d9 // Die Funktion, die anderen Programmen zur Verfügung gestellt werden soll`f`b
`B100`F9d9 // (in diesem Beispiel: Addieren zweier Zahlen)`f`b
`B100`F9d9 function AddNumbers(a, b: Double): Double; cdecl;`f`b
`B100`F9d9 begin`f`b
`B100`F9d9 Result := a + b;`f`b
`B100`F9d9 end;`f`b
`B100`F9d9`f`b
`B100`F9d9 // Exportieren der Funktion`f`b
`B100`F9d9 exports`f`b
`B100`F9d9 AddNumbers;`f`b
`B100`F9d9`f`b
`B100`F9d9 // In diesem Fall muss kein spezieller Initialisierungs-Quellcode angegeben werden`f`b
`B100`F9d9 begin`f`b
`B100`F9d9 end.`f`b

>>>>Eine DLL einbinden / aufrufen

Delphi benötigt keine `B100`F9d9LIB`f`b-Dateien, um eine Funktion korrekt importieren zu können. Zum Einbinden einer DLL muss lediglich das Schlüsselwort `B100`F9d9external`f`b verwendet werden:

`B100`F9d9 program Beispiel;`f`b
`B100`F9d9 {$APPTYPE CONSOLE}`f`b
`B100`F9d9`f`b
`B100`F9d9 // Importieren der Funktion aus einer externen DLL`f`b
`B100`F9d9 function AddNumbers(a, b: Double): Double; cdecl; external 'Beispiel.dll';`f`b
`B100`F9d9`f`b
`B100`F9d9 var result: Double;`f`b
`B100`F9d9 begin`f`b
`B100`F9d9 result := AddNumbers(1, 2);`f`b
`B100`F9d9 Writeln('Das Ergebnis ist: ', result)`f`b
`B100`F9d9 end.`f`b

>>>DLLs in Visual Basic Classic verwenden

Von VB bis zur Version 6 wird nur das Laden von DLLs während der Laufzeit unterstützt. Zusätzlich zur Verwendung der API-Funktionen `B100`F9d9LoadLibrary`f`b und `B100`F9d9GetProcAddress`f`b ist es in Visual Basic aber möglich, externe DLL-Funktionen zu `*deklarieren`*, was für den Entwickler diese Arbeit um einiges einfacher macht:

`B100`F9d9 Option Explicit On`f`b
`B100`F9d9 Declare Function AddNumbers Lib "Example.dll" (ByVal a As Double, ByVal b As Double) As Double`f`b
`B100`F9d9`f`b
`B100`F9d9 Sub Main()`f`b
`B100`F9d9 Dim Result As Double`f`b
`B100`F9d9 Result = AddNumbers(1, 2)`f`b
`B100`F9d9 Debug.Print "Das Ergebnis ist: " & Result`f`b
`B100`F9d9 End Sub`f`b

Wenn beim Laden der DLL-Funktion ein Fehler auftritt, löst VB einen Laufzeitfehler aus. Dieser kann aber abgefangen und behandelt werden. Weiterhin muss man die `F33f`_`[Aufrufkonvention`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Aufrufkonvention]`_`f der exportierten Funktion beachten: Visual Basic nimmt an, dass die Funktion `F33f`_`[_stdcall`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Aufrufkonvention]`_`f ist. Deshalb war bis VB7 der Import von `F33f`_`[_cdecl`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Aufrufkonvention]`_`f-Funktionen nur über eine zwischengeschaltete `F33f`_`[Wrapper`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Wrapper_(Software)]`_`f-DLL möglich.

>>>Win32-DLLs im .Net-Framework verwenden

In .NET werden DLLs mithilfe des DllImport-Attributs eingebunden. Dazu ist der Namespace „System.Runtime.InteropServices“ nötig. Der `F33f`_`[Funktionsprototyp`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Funktionsprototyp]`_`f wird in `F33f`_`[C#`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=C-Sharp]`_`f als „extern“ angegeben, was in `F33f`_`[VB.NET`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=VB.NET]`_`f nicht nötig ist, anschließend kann die Funktion wie jede andere angesprochen werden:

>>>>C#

`B100`F9d9using System;`f`b
`B100`F9d9using System.Runtime.InteropServices;`f`b
`B100`F9d9`f`b
`B100`F9d9namespace DllImportBeispiel`f`b
`B100`F9d9{`f`b
`B100`F9d9 class Program`f`b
`B100`F9d9 {`f`b
`B100`F9d9 [DllImport("Example.dll")]`f`b
`B100`F9d9 static extern double AddNumbers(double a, double b);`f`b
`B100`F9d9`f`b
`B100`F9d9 static void Main()`f`b
`B100`F9d9 {`f`b
`B100`F9d9 Console.WriteLine( AddNumbers( 1, 2 ) );`f`b
`B100`F9d9 }`f`b
`B100`F9d9 }`f`b
`B100`F9d9}`f`b

>>>>VB.NET

`B100`F9d9Imports System.Runtime.InteropServices`f`b
`B100`F9d9`f`b
`B100`F9d9Class Program`f`b
`B100`F9d9 <DllImport("Example.dll")> _`f`b
`B100`F9d9 Private Shared Function AddNumbers(a As Double, b As Double) As Double`f`b
`B100`F9d9 End Function`f`b
`B100`F9d9`f`b
`B100`F9d9 Private Shared Sub Main()`f`b
`B100`F9d9 Console.WriteLine(AddNumbers(1, 2))`f`b
`B100`F9d9 End Sub`f`b
`B100`F9d9End Class`f`b

>>>>Direkte Einbindung von DLLs in Visual Studio

Wenn jedoch auf mehrere Methoden oder Funktionen einer DLL zugegriffen werden soll, kann diese auch über den Projekt Explorer von `F33f`_`[Visual Studio`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Visual_Studio]`_`f direkt eingebunden werden.`:cite-ref-5[`F5bf`_`[5`#cite-note-5]`_`f] Anschließend können die Funktionen der DLL verwendet werden, indem man entweder im Code den vollständigen Namespace vor der Klasse der Methode angibt, oder indem man mit using (C#) beziehungsweise Imports (VB.Net) den Namespace direkt einbindet. Bei dieser Vorgehensweise wird der System.Runtime.InteropServices Namespace nicht benötigt.

Im Folgenden ist obiges Beispiel mit direkt eingebundener DLL veranschaulicht (der Namespace entspricht hier dem Namen der DLL):

>>>>C#

`B100`F9d9using Example;`f`b
`B100`F9d9`f`b
`B100`F9d9class Program`f`b
`B100`F9d9{`f`b
`B100`F9d9 static void Main()`f`b
`B100`F9d9 {`f`b
`B100`F9d9 Console.WriteLine(AddNumbers(1, 2));`f`b
`B100`F9d9 }`f`b
`B100`F9d9}`f`b

>>>>VB.Net

`B100`F9d9Imports Example`f`b
`B100`F9d9`f`b
`B100`F9d9Class Program`f`b
`B100`F9d9 Private Shared Sub Main()`f`b
`B100`F9d9 Console.WriteLine(AddNumbers(1, 2))`f`b
`B100`F9d9 End Sub`f`b
`B100`F9d9End Class`f`b

>>Siehe auch

• `F33f`_`[Dependency Walker`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Dependency_Walker]`_`f, Bestandteil des Microsoft Visual Studio bis zur Version 2005, mit dem man sich Funktionen, die ein Programm ex- und importiert, hierarchisch anzeigen lassen kann.

>>Weblinks

• Verwenden von _declspec(dllimport) und _declspec(dllexport) bei `F33f`_`[MSDN Library`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=MSDN_Library]`_`f
• `*Win32 DLL`* – Anleitung, wie man in C++ mit `F33f`_`[Visual Studio`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Visual_Studio]`_`f DLLs erstellen und aufrufen kann (englisch)
• Durch Grafiken und Videos unterstützte Beschreibung der Windows Bibliotheken. Statische Libs und DLLs.
• `*What is so special about the instance handle 0x10000000?`* by Raymond Chen (englisch)

>>Einzelnachweise

`:cite-note-1`!1.`! `F0af`_`[↑`#cite-ref-1]`_`f `*Was ist Dynamic Link Library (DLL)? - Definition von WhatIs.com.`* Abgerufen am 24. Mai 2022.
`:cite-note-2`!2.`! `F0af`_`[↑`#cite-ref-2]`_`f `*DLL-Datei - was ist das?`* Abgerufen am 24. Mai 2022.
`:cite-note-ne-3`!3.`! `F0af`_`[↑`#cite-ref-ne-3-0]`_`f K. B. Microsoft: Executable-File Header Format
`:cite-note-4`!4.`! `F0af`_`[↑`#cite-ref-4]`_`f Deland-Han: `*Dynamic Link Library (DLL) - Windows Client.`* Abgerufen am 24. Mai 2022 (deutsch).
`:cite-note-5`!5.`! `F0af`_`[↑`#cite-ref-5]`_`f corob-msft: `*Walkthrough: Create and use your own Dynamic Link Library (C++).`* Abgerufen am 24. Mai 2022 (amerikanisches Englisch).

`c`F0af`_`[↑ Back to top`#top]`_`f`a